“Verification” is the term that is often used to refer to the process of determining whether a design meets requirements. In practice, verification is the process of identifying and removing as many functional bugs in the hardware and software as possible. The oldest form of verification is to build it, run it, and watch what happens.
Hardware verification may be performed by verifying individual functional blocks in a design using constrained random testbenches, code coverage, assertion coverage, and functional coverage. The key is that a set of “tests” are created to verify the expected performance of the hardware design. For example, verification test data can be generated for the device under test using a constraint-based random test generation process, in which the verification test data is defined in response to constraint data and an input/output data model. Such constraint data and input/output data model may be defined using a verification specific programming language, such as the “e” programming language.
For software, essential steps for the modern software development process are the steps of testing and debugging software to ensure that the software will work and function as expected in its intended processing environment. These steps are usually implemented as methodical processes of finding and reducing the number of defects in the software program to make it behave as expected or intended. To avoid the cumbersome, time-consuming, and complicated task of manually performing software verification, tests may be created to verify the software. Like the tests defined for hardware verification, tests for software verification may be generated based upon input/output data models and constraint data.
Verification may also need to be performed on designs that include both hardware and software elements. For example, embedded software is a type of software (or firmware) that is designed to interact and interface in an integral way with a specific system or item of hardware. Designing and testing embedded software is considered to be very challenging for many designers since it normally require a multi-disciplinary approach to systems design that must take into account multifaceted effects throughout the different parts of the system. The programmer must consider many acute constraints for a successful design, such as energy consumption, memory space, criticality and safety considerations, and execution time. The task of verifying such designs is difficult since the software program is tightly coupled to other devices or subsystems, and it often difficult to determine and test the complex interactions between the software and the other subsystems and components in the overall system. Moreover, changes in one part of the system may cause unexpected results and errors to emerge in other parts the system. Therefore, adequate tests are particularly important to the process of verifying deigns having both hardware and software.
Modern software/hardware verification environments often require many thousands of tests written in some programming language. Those tests may be automatically generated by machine or manually created by developers and engineers.
As a natural part of the development cycle some of those tests fail, and need to be debugged by the developers in order to capture and fix the error. The traditional way to debug and minimize failures is doing it by hand in a manner of trial and error. However, the effort to understand a very complex test is often exhaustive, particularly if the complex test is generated by a machine to include a very large number test statements and elements. Therefore, with complex tests, it may be extremely difficult to understand and debug an error manually.